package cn.liu.hrm.service.impl;

import cn.liu.hrm.constantis.RedisConstantis;
import cn.liu.hrm.domain.CourseType;
import cn.liu.hrm.feignclient.RedisFeignClient;
import cn.liu.hrm.mapper.CourseTypeMapper;
import cn.liu.hrm.service.ICourseTypeService;
import cn.liu.hrm.util.AjaxResult;
import cn.liu.hrm.vo.CrumbsVo;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * 课程目录 服务实现类
 * </p>
 *
 * @author Mr.liu
 * @since 2020-03-24
 */
@Service
public class CourseTypeServiceImpl extends ServiceImpl<CourseTypeMapper, CourseType> implements ICourseTypeService {

    @Autowired
    private RedisFeignClient redisFeignClient;

    /*
     * 缓存逻辑：
     *   1.通过RedisFeig查询Redis缓存中是否有数据：课程分类
     *   2.如果有，直接返回
     *   3.如果没有：
     *       3.1.从数据库中查询课程分类
     *       3.2.把查询到的数据缓存到Redis中
     *   4.返回结果
     * */
    private List<CourseType> selectCourseTypeFromRedis() {
        //1.通过RedisFeig查询Redis缓存中是否有数据：课程分类
        AjaxResult allCourseTypeResult = redisFeignClient.getString(RedisConstantis.KEY_ALLCOURSETYPE);
        if(allCourseTypeResult.isSuccess() && allCourseTypeResult.getResultObj() != null){
            //json格式的缓存数据
            String jsonString  = allCourseTypeResult.getResultObj().toString();
            // 2.如果有：直接返回
            //把json字符串转成  List<CourseType>  - fastjson
            //对象转字符串：JSON.toJsonString
            //字符串转对象：JSON.parseObject
            //字符串转list：JSON.parseArray
            List<CourseType> courseTypesFromRedis = JSON.parseArray(jsonString, CourseType.class);
            return courseTypesFromRedis;
        }else{
            //3.如果没有：
            //3.1.从数据库中查询课程分类
            //1.查询出所有的课程分类 -> 26条
            List<CourseType> allCourseType = baseMapper.selectList(null);
            //3.2.把查询到的数据缓存到Redis中
            AjaxResult allCourseTypeSetResult = redisFeignClient.setString(RedisConstantis.KEY_ALLCOURSETYPE, JSON.toJSONString(allCourseType));
            //4.返回结果
            return allCourseType;
        }
    }

    @Override
    public List<CourseType> treeData() {

        //加入缓存逻辑

        //1.查询出所有的课程分类 -> 26条
        List<CourseType> allCourseType = selectCourseTypeFromRedis();//baseMapper.selectList(null);

        //2.从所有的分类中，过滤出 5 条一级分类
        //一级分类集合
        List<CourseType> parentCourseTypes = new ArrayList<>();

        for (CourseType currentCourseType : allCourseType) {

            //3.如果某个分类的 pid == 0,那么这个分类就是一级分类
            if (currentCourseType.getPid() == 0) {
                parentCourseTypes.add(currentCourseType);
            } else {

                //4.如果不是一级分类，就去找自己的父分类，加入父分类的children
                for (CourseType parentCourseType : allCourseType) {

                    //如果当前分类的pid等于某个分类的id,那么这个分类就是它的父分类
                    if (currentCourseType.getPid().equals(parentCourseType.getId())) {
                        //把currentCourseType 当前分类加入 父分类parentCourseType的 children
                        parentCourseType.getChildren().add(currentCourseType);
                        break;
                    }
                }
            }
        }
        return parentCourseTypes;
    }

    @Override
    public List<CrumbsVo> crumbs(Long courseTypeId) {
        //1.根据分类ID查询分类对象
        CourseType courseType = baseMapper.selectById(courseTypeId);

        //2.获取当前分类的path : .1037.1039.1040.
        String path = courseType.getPath();
        //去掉两边的 “.”   如：  1037.1039.1040.
        path = path.startsWith(".")?path.substring(1) : path;
        //1037.1039.1040
        path = path.endsWith(".")?path.substring(0,path.length() -1 ) : path;

        //3.切割path : [1037 , 1039 , 1040]
        String[] courseTypeIds = path.split("\\.");

        List<CrumbsVo> result = new ArrayList<>();

        //4.遍历切割后的分类ID数组
        for(String courseTypeIdStr : courseTypeIds){

            CrumbsVo vo = new CrumbsVo();
            //1037
            Long currentCourseTypeId  = Long.valueOf(courseTypeIdStr) ;

            //5.查询当前遍历到的分类的对象 ：1037
            CourseType currentCourseType = baseMapper.selectById(currentCourseTypeId);

            //6.把当前分类装到 CrumbsVo.ownerProductType
            vo.setOwnerProductType(currentCourseType);

            //7.根据当前遍历到的分类查找其兄弟姐妹列表，pid相同的就是兄弟姐妹
            List<CourseType>  otherProductTypes = baseMapper.selectByPid(currentCourseType.getPid(),currentCourseType.getId());

            //8.把兄弟姐妹列表放到CrumbsVo.otherProductTypes
            vo.setOtherProductTypes(otherProductTypes);

            //9.把所有的CrumbsVo装到List，返回
            result.add(vo);
        }
        return result;
    }

    //新增方法
    @Override
    public boolean insert(CourseType entity) {
        boolean result = super.insert(entity);
        //重置Redis
        if (result){
            //3.如果没有：
            //3.1.从数据库中查询课程分类
            //1.查询出所有的课程分类 -> 26条
            List<CourseType> allCourseType = baseMapper.selectList(null);
            //3.2.把查询到的数据缓存到Redis中
            AjaxResult allCourseTypeSetResult = redisFeignClient.setString(RedisConstantis.KEY_ALLCOURSETYPE, JSON.toJSONString(allCourseType));
            if (!allCourseTypeSetResult.isSuccess()){
                throw new RuntimeException("重置缓存失败");
            }
        }
        return result;
    }

    //修改数据方法
    @Override
    public boolean updateById(CourseType entity) {
        boolean result = super.updateById(entity);
        //重置Redis
        if (result){
            List<CourseType> allCourseType = baseMapper.selectList(null);
            AjaxResult allCourseTypeSetResult = redisFeignClient.setString(RedisConstantis.KEY_ALLCOURSETYPE, JSON.toJSONString(allCourseType));
            if (!allCourseTypeSetResult.isSuccess()){
                throw new RuntimeException("重置缓存失败");
            }
        }
        return result;
    }

    //删除数据方法
    @Override
    public boolean deleteById(Serializable id) {
        boolean result = super.deleteById(id);
        //重置Redis
        if (result){
            List<CourseType> allCourseType = baseMapper.selectList(null);
            AjaxResult allCourseTypeSetResult = redisFeignClient.setString(RedisConstantis.KEY_ALLCOURSETYPE, JSON.toJSONString(allCourseType));
            if (!allCourseTypeSetResult.isSuccess()){
                throw new RuntimeException("重置缓存失败");
            }
        }
        return result;
    }
}
